```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>深入理解Spring事务传播机制</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        .hero {
            background: linear-gradient(135deg, #6e8efb 0%, #a777e3 100%);
        }
        .code-block {
            background: #2d2d2d;
            border-radius: 8px;
            position: relative;
        }
        .code-block pre {
            margin: 0;
            padding: 1.5rem;
            overflow-x: auto;
        }
        .code-block::before {
            content: '';
            position: absolute;
            top: 12px;
            left: 12px;
            width: 12px;
            height: 12px;
            border-radius: 50%;
            background: #ff5f56;
            box-shadow: 20px 0 0 #ffbd2e, 40px 0 0 #27c93f;
        }
        .propagation-card {
            transition: all 0.3s ease;
            border-left: 4px solid #6e8efb;
        }
        .propagation-card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 20px rgba(0,0,0,0.1);
        }
        .highlight {
            background: linear-gradient(90deg, rgba(110,142,251,0.1) 0%, rgba(167,119,227,0.1) 100%);
            padding: 2px 4px;
            border-radius: 4px;
        }
        .section-divider {
            height: 1px;
            background: linear-gradient(90deg, rgba(110,142,251,0) 0%, rgba(110,142,251,0.5) 50%, rgba(110,142,251,0) 100%);
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero text-white py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-4xl">
            <div class="flex flex-col items-center text-center">
                <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">深入理解Spring事务传播机制</h1>
                <p class="text-xl md:text-2xl opacity-90 mb-8 max-w-2xl">探索Spring事务管理的核心原理与最佳实践</p>
                <div class="flex space-x-4">
                    <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">@Transactional</span>
                    <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">Propagation</span>
                    <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">Spring Framework</span>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-4xl px-4 md:px-0 py-12">
        <!-- Introduction Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-question-circle mr-3 text-blue-500"></i>
                为什么会有事务的传播机制？
            </h2>
            <div class="bg-white rounded-xl shadow-md p-6 mb-8">
                <p class="text-lg text-gray-700 mb-6">
                    事务传播机制是为了控制在一个事务范围内调用其他事务的行为。它能够确保事务在嵌套调用中的正确执行，同时保持事务的一致性和完整性。事务传播机制的存在主要是因为在复杂的应用场景中，不同的方法可能会涉及到多个事务，并且这些事务之间可能存在依赖关系。为了保证数据的一致性和完整性，必须对事务的传播行为进行精确地控制。
                </p>
                <div class="flex justify-center my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708313142441-7069e586-f48f-41dd-b5aa-5f7d0d5abb81.png" alt="事务传播机制示意图" class="rounded-lg shadow-md max-w-full h-auto">
                </div>
                <p class="text-lg text-gray-700 mb-6">
                    举例来说，假设在一个电子商务系统中，有一个服务方法A负责处理用户下单操作，而另一个服务方法B则负责处理支付操作。这两个方法分别在不同的事务中执行。如果用户下单成功后立即调用支付方法，那么支付方法也应该在同一个事务中执行，以确保订单的一致性。这时就需要通过事务传播机制来指定支付方法以何种方式参与到下单方法的事务中。
                </p>
                <div class="flex justify-center my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708313170623-9bfe218d-a260-4ff8-b3ac-f0a34a2c5822.png" alt="电商事务示例" class="rounded-lg shadow-md max-w-full h-auto">
                </div>
                <div class="code-block my-6">
                    <pre class="text-gray-200"><code>import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    @Transactional
    public void placeOrder() {
        // 处理用户下单操作，包括创建订单、更新库存等

        // 下单成功后立即调用支付方法
        paymentService.processPayment();
    }
}

@Service
public class PaymentService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void processPayment() {
        // 处理支付操作，包括扣款、更新订单状态等
    }
}</code></pre>
                </div>
                <p class="text-lg text-gray-700">
                    因此，事务传播机制能够根据不同的场景和需求，灵活地控制事务的边界和执行方式，保证整个业务流程的正确性和可靠性。简单来说就是对于业务层而言只有一个操作，但是数据层分成了两次事务来做。但是两次事务是没有任何关系的。
                </p>
            </div>
        </section>

        <!-- Divider -->
        <div class="section-divider my-12"></div>

        <!-- Propagation Mechanism Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-project-diagram mr-3 text-purple-500"></i>
                事务的传播机制
            </h2>
            <div class="bg-white rounded-xl shadow-md p-6">
                <p class="text-lg text-gray-700 mb-8">
                    Spring事务的传播机制是指在多个事务方法相互调用时，事务如何在这些方法之间进行传播和管理。Spring定义了7种事务传播行为，每种行为对应不同的事务管理策略：
                </p>
                <div class="flex justify-center my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708313356214-fb9045b1-3dd0-4b01-95f4-7c2c4df49047.png" alt="事务传播类型" class="rounded-lg shadow-md max-w-full h-auto">
                </div>
                <div class="grid md:grid-cols-2 gap-6 mt-8">
                    <div class="propagation-card bg-white p-6 rounded-lg shadow-sm border-l-4 border-blue-500">
                        <h3 class="text-xl font-bold mb-3 text-gray-800">1. REQUIRED（默认）</h3>
                        <p class="text-gray-700">如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是最常用的传播行为，适用于绝大多数情况。</p>
                    </div>
                    <div class="propagation-card bg-white p-6 rounded-lg shadow-sm border-l-4 border-purple-500">
                        <h3 class="text-xl font-bold mb-3 text-gray-800">2. SUPPORTS</h3>
                        <p class="text-gray-700">如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。适用于只读操作或不需要事务的场景。</p>
                    </div>
                    <div class="propagation-card bg-white p-6 rounded-lg shadow-sm border-l-4 border-green-500">
                        <h3 class="text-xl font-bold mb-3 text-gray-800">3. MANDATORY</h3>
                        <p class="text-gray-700">如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。适用于必须在事务中执行的场景。</p>
                    </div>
                    <div class="propagation-card bg-white p-6 rounded-lg shadow-sm border-l-4 border-yellow-500">
                        <h3 class="text-xl font-bold mb-3 text-gray-800">4. REQUIRES_NEW</h3>
                        <p class="text-gray-700">创建一个新的事务，并且暂停当前事务（如果存在）。适用于需要独立的事务运行的场景。</p>
                    </div>
                    <div class="propagation-card bg-white p-6 rounded-lg shadow-sm border-l-4 border-red-500">
                        <h3 class="text-xl font-bold mb-3 text-gray-800">5. NOT_SUPPORTED</h3>
                        <p class="text-gray-700">以非事务方式执行，并且暂停当前事务（如果存在）。适用于不需要事务的场景。</p>
                    </div>
                    <div class="propagation-card bg-white p-6 rounded-lg shadow-sm border-l-4 border-indigo-500">
                        <h3 class="text-xl font-bold mb-3 text-gray-800">6. NEVER</h3>
                        <p class="text-gray-700">以非事务方式执行，如果当前存在事务，则抛出异常。适用于不能在事务中执行的场景。</p>
                    </div>
                    <div class="propagation-card bg-white p-6 rounded-lg shadow-sm border-l-4 border-pink-500 md:col-span-2">
                        <h3 class="text-xl font-bold mb-3 text-gray-800">7. NESTED</h3>
                        <p class="text-gray-700">如果当前存在事务，则在当前事务的嵌套事务中执行；如果当前没有事务，则创建一个新的事务。如果外层事务回滚，内层事务也会回滚，但内层事务的提交不会影响外层事务的提交。适用于需要嵌套事务的场景。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Divider -->
        <div class="section-divider my-12"></div>

        <!-- Transactional Annotation Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-code mr-3 text-green-500"></i>
                @Transactional注解的使用
            </h2>
            <div class="bg-white rounded-xl shadow-md p-6">
                <p class="text-lg text-gray-700 mb-6">
                    <span class="highlight font-medium">@Transactional</span> 注解是 Spring 框架提供的一个注解，用于声明事务管理的行为。它可以应用在类级别或方法级别上，并允许开发者对方法或类进行事务管理的配置。
                </p>
                
                <h3 class="text-2xl font-bold mt-8 mb-4 text-gray-800">作用</h3>
                <div class="grid md:grid-cols-2 gap-4 mb-8">
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2 flex items-center">
                            <i class="fas fa-check-circle mr-2 text-blue-500"></i>
                            声明事务范围
                        </h4>
                        <p class="text-gray-700"><span class="highlight">@Transactional</span> 注解可以将方法或类中的操作纳入事务管理范围内，保证操作的原子性、一致性、隔离性和持久性（ACID）。</p>
                    </div>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2 flex items-center">
                            <i class="fas fa-cogs mr-2 text-purple-500"></i>
                            简化事务管理配置
                        </h4>
                        <p class="text-gray-700">使用 <span class="highlight">@Transactional</span> 注解可以简化事务管理的配置，避免手动编写事务管理代码。</p>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-8 mb-4 text-gray-800">使用方式</h3>
                <div class="grid md:grid-cols-2 gap-6 mb-8">
                    <div>
                        <h4 class="text-xl font-semibold mb-3 text-gray-800 flex items-center">
                            <i class="fas fa-bolt mr-2 text-yellow-500"></i>
                            在方法级别使用
                        </h4>
                        <p class="text-gray-700 mb-4">将 <span class="highlight">@Transactional</span> 注解应用在方法上，表示该方法内的操作应该在一个事务中执行。</p>
                        <div class="code-block">
                            <pre class="text-gray-200"><code>import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Transactional
    public void createUser(User user) {
        // 在该方法中执行数据库操作，将用户信息保存到数据库中
    }

    @Transactional(propagation = Propagation.REQUIRED, 
                   isolation = Isolation.READ_COMMITTED)
    public void updateUser(User user) {
        // 在该方法中执行数据库操作，更新用户信息
    }
}</code></pre>
                        </div>
                    </div>
                    <div>
                        <h4 class="text-xl font-semibold mb-3 text-gray-800 flex items-center">
                            <i class="fas fa-layer-group mr-2 text-green-500"></i>
                            在类级别使用
                        </h4>
                        <p class="text-gray-700 mb-4">将 <span class="highlight">@Transactional</span> 注解应用在类上，表示该类中的所有方法都应该在一个事务中执行。</p>
                        <div class="code-block">
                            <pre class="text-gray-200"><code>import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class UserService {

    public void createUser(User user) {
        // 在该方法中执行数据库操作，将用户信息保存到数据库中
    }

    public void updateUser(User user) {
        // 在该方法中执行数据库操作，更新用户信息
    }
}</code></pre>
                        </div>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-8 mb-6 text-gray-800">注解属性</h3>
                <div class="flex justify-center my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708333821528-fd3dc86a-fce5-455d-8d5b-6c36393c4c90.png" alt="事务注解属性" class="rounded-lg shadow-md max-w-full h-auto">
                </div>
                <div class="grid md:grid-cols-2 gap-6">
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2">
                            <span class="highlight">value / transactionManager</span>
                        </h4>
                        <p class="text-gray-700">指定事务管理器的名称或ID。当应用中存在多个事务管理器时，通过这个属性可以指定使用哪个事务管理器来管理当前方法的事务。</p>
                        <div class="code-block mt-3">
                            <pre class="text-gray-200"><code>@Transactional(value = "transactionManager")</code></pre>
                        </div>
                    </div>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2">
                            <span class="highlight">propagation</span>
                        </h4>
                        <p class="text-gray-700">指定事务的传播行为。包括多种传播行为，如REQUIRED、REQUIRES_NEW、SUPPORTS等。用于控制方法在不同事务上下文中的行为。</p>
                        <div class="code-block mt-3">
                            <pre class="text-gray-200"><code>@Transactional(propagation = Propagation.REQUIRED)</code></pre>
                        </div>
                    </div>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2">
                            <span class="highlight">isolation</span>
                        </h4>
                        <p class="text-gray-700">指定事务的隔离级别。用于控制事务之间的相互影响程度，包括READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE等级别。</p>
                        <div class="code-block mt-3">
                            <pre class="text-gray-200"><code>@Transactional(isolation = Isolation.READ_COMMITTED)</code></pre>
                        </div>
                    </div>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2">
                            <span class="highlight">readOnly</span>
                        </h4>
                        <p class="text-gray-700">指定事务是否为只读事务。如果设置为true，则表示当前事务只会读取数据，不会进行修改操作，可以优化事务的性能。</p>
                        <div class="code-block mt-3">
                            <pre class="text-gray-200"><code>@Transactional(readOnly = true)</code></pre>
                        </div>
                    </div>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2">
                            <span class="highlight">timeout</span>
                        </h4>
                        <p class="text-gray-700">指定事务的超时时间，单位为秒。如果在指定的时间内事务没有执行完毕，则会自动回滚。</p>
                        <div class="code-block mt-3">
                            <pre class="text-gray-200"><code>@Transactional(timeout = 60)</code></pre>
                        </div>
                    </div>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <h4 class="font-bold text-lg text-gray-700 mb-2">
                            <span class="highlight">rollbackFor / rollbackForClassName / noRollbackFor / noRollbackForClassName</span>
                        </h4>
                        <p class="text-gray-700">指定在哪些异常情况下进行事务回滚或不回滚。可以通过异常的类名或类型来指定。</p>
                        <div class="code-block mt-3">
                            <pre class="text-gray-200"><code>@Transactional(rollbackFor = Exception.class, 
               noRollbackFor = BusinessException.class)</code></pre>
                        </div>
                    </div>
                    <div class="bg-gray-50 p-4 rounded-lg md:col-span-2">
                        <h4 class="font-bold text-lg text-gray-700 mb-2">
                            <span class="highlight">name / value</span>
                        </h4>
                        <p class="text-gray-700">指定一个或多个Spring Bean的名称，用于应用Bean名称限定事务。</p>
                        <div class="code-block mt-3">
                            <pre class="text-gray-200"><code>@Transactional(value = "transactionManager", 
               name = "myTransaction")</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Visualization Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-chart-network mr-3 text-red-500"></i>
                事务传播机制可视化
            </h2>
            <div class="bg-white rounded-xl shadow-md p-6">
                <div class="mermaid">
                    graph TD
                        A[调用方法] -->|REQUIRED| B[当前有事务?]
                        B -->|是| C[加入当前事务]
                        B -->|否| D[创建新事务]
                        A -->|REQUIRES_NEW| E[创建新事务]
                        E --> F[暂停当前事务]
                        A -->|NESTED| G[当前有事务?]
                        G -->|是| H[创建嵌套事务]
                        G -->|否| I[创建新事务]
                        A -->|SUPPORTS| J[当前有事务?]
                        J -->|是| K[加入当前事务]
                        J -->|否| L[非事务执行]
                        A -->|NOT_SUPPORTED| M[非事务执行]
                        M --> N[暂停当前事务]
                        A -->|NEVER| O[非事务执行]
                        O --> P[当前有事务?]
                        P -->|是| Q[抛出异常]
                        A -->|MANDATORY| R[当前有事务?]
                        R -->|是| S[加入当前事务]
                        R -->|否| T[抛出异常]
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8">
        <div class="container mx-auto max-w-4xl px-4 text-center">
            <div class="flex flex-col items-center">
                <div class="mb-4">
                    <p class="text-lg font-medium">技术小馆</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-blue-300 hover:text-white transition-colors duration-300">
                        <i class="fas fa-external-link-alt mr-2"></i>
                        http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```